<?php
/**
 * Représente une liste de traduction
 *
 * @author Kévin Fauconnet (05/08/2013)
 */


class Translation_List extends SimpleModel {
	
	public $id_list;
	public $libelle;
	public $shared;
	public $last_update;

	public $id_user;
	
	public $translations;
	public $user;
	
	public function sqltable() { return "translation_lists"; }
	
	public function schema() { return array(
		'id_list'				=> array('primarykey' => true, 'type' => 'int'),
		'libelle'				=> 'string(128)',
		'shared' 				=> 'bool',
		'last_update' 			=> 'datetime',
		'id_user'				=> 'int'
	); }
	
	/**
	 * Crée un nouvel objet
	 */
	public function __construct($param = array()) {
		$this->id_list = 0;
		$this->libelle = '';
		$this->shared = true;
		$this->last_update = null;
		$this->id_user = 0;
		
		$this->translations = array();

		$this->init($param);
	}
	
	/**
	 * Remplit l'objet depuis les résultats d'un PDOStatement
	 */
	public function fromStatement($rowFetched, $st) {
		parent::fromStatement($rowFetched);
		
		if (!empty($rowFetched['email'])) {
			require_once(CLASS_PATH.'user.class.php');
			$user = new User($rowFetched);
			$this->user = $user;
		}
		
	}
	
	/**
	 * Sauvegarde l'objet, et met à jour l'attribut last_update
	 */
	public function save($options = array()) {
		$this->last_update = date('d/m/Y H:i:s');
		$res = parent::save($options);
		return $res;
	}
	
	/** 
	 * Supprime l'objet ainsi que ses liens
	 */
	public function delete() {
		$result = parent::delete();
		$sql = "DELETE FROM translation_lists_items WHERE id_list = ?";
		$st = self::buildQuery(array(
			'query' => $sql,
			'values' => array($this->id_list)
		));
		return $result;
	}
	
	
	/**
	 * Ajoute de nouvelles traductions à une liste
	 */
	public function addTranslations($ids_translation) {
		$sql = "INSERT INTO translation_lists_items (id_list, id_translation) VALUES (?, ?)";
		
		foreach ($ids_translation as $id_translation) {
			$values = array($this->id_list, $id_translation);
			$st = self::buildQuery(array(
				'query' => $sql,
				'values' => $values
			));
		}
	}
	
	/**
	 * Supprime des traductions à une liste
	 */
	public function removeTranslations($ids_translation) {
		$sql = "DELETE FROM translation_lists_items";
		$where = array();
		$where[] = array('AND', 'id_list = ?', $this->id_list);
		$where[] = array('AND', 'id_translation IN ?', $ids_translation);
		$st = self::buildQuery(array(
			'query' => $sql,
			'where' => $where
		));
	}
	
	/**
	 * Récupère les ids de traductions associées à la liste
	 */
	public function getIdsTranslation() {
		$sql = "SELECT * FROM translation_lists_items WHERE id_list = ?";
		$st = self::buildQuery(array(
			'query' => $sql,
			'values' => array($this->id_list)
		));
		$ids_translation = array();
		
		while ($row = $st->fetch()) {
			$ids_translation[] = $row['id_translation'];
		}
		return $ids_translation;
	}
	
	/**
	 * Obtient les traducitons liés à la liste
	 */
	public function getTranslations() {
		require_once(CLASS_PATH.'translation.class.php');
		$ids_translation = $this->getIdsTranslation();
		
		$translations = array();
		if (!empty($ids_translation)) {
			$translations = Translation::getTranslations(array(
				'ids' 		=> $ids_translation,
				'withTerm' 	=> true
			));
		}
		$this->translations = $translations;
		return $translations;
	}

	/**
	 * Construit la requête de traductions et l'exécute
	 *
	 * Options possible:
	 * - id_user: listes d'un utilisateur
	 * - withUser: (boolean) permet de récupérer les données de l'utilisateur associé (jointure)
	 * - visibleForUser: (boolean) permet de récupérer toute les listes visibles par un utilisateur précis (les siennes + celles partagées)
	 *
	 * @param $options Array options
	 * @return PDOStatement le statement lié à la requête
	 */		
	public static function buildQueryTranslationLists($options = array()) {
		
		$sql = "SELECT * FROM translation_lists";
		
		if (!empty($options['count'])) {
			$sql = "SELECT COUNT(*) FROM translation_lists";
		}
		
		else if (!empty($options['withUser'])) {
			$sql .= " LEFT JOIN users ON users.id_user = translation_lists.id_user";
		}
		
		$where = array();

		if (!empty($options['id_user'])) {
			$where[] = array('AND', 'id_user = ?', $options['id_user']);
		}
		
		if (!empty($options['visibleForUser'])) {
			$where[] = array('AND', '(shared = 1 OR id_user = ?)', $options['visibleForUser']);
		}
		
		$queryOptions = array(
			'query' => $sql,
			'where' => $where
		);
		if (empty($options['count'])) {
			$queryOptions += array(
				'orderby' => 	self::getOption($options, 'orderby', 'libelle'),
				'limit' => 		self::getOption($options, 'limit'),
				'offset' => 	self::getOption($options, 'offset'),
				'page' => 		self::getOption($options, 'page')
			);
		}
		
		return self::buildQuery($queryOptions);
	}
	
	/**
	 * Renvoie le total de traductions
	 * Options possible:
	 * - id_user: listes d'un utilisateur
	 * - withUser: (boolean) permet de récupérer les données de l'utilisateur associé (jointure)
	 * - visibleForUser: (boolean) permet de récupérer toute les listes visibles par un utilisateur précis (les siennes + celles partagées)
	 *
	 * @param $options Array options
	 * @return Array<int> liste d'id_translation
	 */		
	public static function countTranslationLists($options = array()) {
	
		$options['count'] = true;
		
		$st = self::buildQueryTranslationLists($options);
		$total = $st->fetchOne('int');
		return $total;
	}
	
	/**
	 * Renvoie une liste de traductions
	 * Options possible:
	 * - id_user: listes d'un utilisateur
	 * - withUser: (boolean) permet de récupérer les données de l'utilisateur associé (jointure)
	 * - visibleForUser: (boolean) permet de récupérer toute les listes visibles par un utilisateur précis (les siennes + celles partagées)
	 * - orderby
	 * - limit
	 * - offset
	 * - page
	 *
	 * @param $options Array options
	 * @return Array<Translation_List> listes de liste de traductions
	 */		
	public static function getTranslationLists($options = array()) {
		$st = self::buildQueryTranslationLists($options);
		
		$results = array();

		while ($st->fetch()) {
			if (!empty($options['index_by_id'])) {
				$o = new self($st);
				$results[$o->id_list] = $o;
			}
			else {
				$results[] = new self($st);
			}
		}
		return $results;
	}
	
	/**
	 * Renvoie le nombre de traductions contenus dans des listes
	 */
	public static function getNbTranslations($options = array()) {
		$sql = "SELECT COUNT(*) total, id_list FROM translation_lists_items";
		$where = array();
		
		if (!empty($options['ids'])) {
			$where[] = array('AND', 'id_list IN ?', $options['ids']);
		}
		
		$st = self::buildQuery(array(
			'query' => $sql,
			'where' => $where,
			'groupby' => 'id_list'
		));	
		
		$nb_translations = array();
		while ($row = $st->fetch()) {
			$nb_translations[$row['id_list']] = $row['total'];
		}
		
		return $nb_translations;
		
	}
}
?>